<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Reference Documentation</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.79.1">
<link rel="home" href="../index.html" title="CallableTraits">
<link rel="up" href="../index.html" title="CallableTraits">
<link rel="prev" href="../index.html" title="CallableTraits">
<link rel="next" href="faq.html" title="FAQ">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="faq.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="callable_traits.reference"></a><a class="link" href="reference.html" title="Reference Documentation">Reference Documentation</a>
</h2></div></div></div>
<div class="toc"><dl class="toc">
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_member_const">add_member_const</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_member_cv">add_member_cv</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference">add_member_lvalue_reference</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference">add_member_rvalue_reference</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_member_volatile">add_member_volatile</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_noexcept">add_noexcept</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_transaction_safe">add_transaction_safe</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_add_varargs">add_varargs</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_apply_member_pointer">apply_member_pointer</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_apply_return">apply_return</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_args">args</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_class_of">class_of</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_function_type">function_type</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_has_member_qualifiers">has_member_qualifiers</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_has_varargs">has_varargs</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_has_void_return">has_void_return</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_const_member">is_const_member</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_cv_member">is_cv_member</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_invocable">is_invocable</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member">is_lvalue_reference_member</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_reference_member">is_reference_member</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member">is_rvalue_reference_member</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_noexcept">is_noexcept</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_transaction_safe">is_transaction_safe</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_is_volatile_member">is_volatile_member</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_qualified_class_of">qualified_class_of</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_member_const">remove_member_const</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_member_cv">remove_member_cv</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_member_reference">remove_member_reference</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_member_volatile">remove_member_volatile</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_noexcept">remove_noexcept</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_transaction_safe">remove_transaction_safe</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_remove_varargs">remove_varargs</a></span></dt>
<dt><span class="section"><a href="reference.html#callable_traits.reference.ref_return_type">return_type</a></span></dt>
</dl></div>
<p>
      This reference will be most beneficial to readers familiar with the following
      C++ topics:
    </p>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/partial_specialization" target="_top">template
          specializations</a>
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/sfinae" target="_top">SFINAE</a>
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/utility/functional/invoke" target="_top"><code class="literal"><span class="emphasis"><em>INVOKE</em></span></code></a>
          rules
        </li>
<li class="listitem">
          function types
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/pointer#Pointers_to_functions" target="_top">function
          pointers</a>
        </li>
<li class="listitem">
          <a href="http://stackoverflow.com/questions/480248/function-references" target="_top">function
          references</a>
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/pointer#Pointers_to_member_functions" target="_top">pointers
          to member functions</a> (a.k.a. PMFs)
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/pointer#Pointers_to_data_members" target="_top">pointers
          to data members</a> (a.k.a. PMDs)
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/operators#Function_call_operator" target="_top">the
          function call operator, <code class="literal">operator()</code></a>
        </li>
<li class="listitem">
          <a href="https://isocpp.org/blog/2012/11/universal-references-in-c11-scott-meyers" target="_top">universal
          references</a> and <a href="http://stackoverflow.com/questions/13725747/concise-explanation-of-reference-collapsing-rules-requested-1-a-a-2" target="_top">reference
          collapsing rules</a>
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/cpp/language/member_functions#const-.2C_volatile-.2C_and_ref-qualified_member_functions" target="_top">cv-qualified
          and ref-qualified member functions</a>
        </li>
<li class="listitem">
          <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2015/p0172r0.html" target="_top">"abominable"
          function types</a>
        </li>
<li class="listitem">
          <a href="http://en.cppreference.com/w/c/language/variadic" target="_top">C-style variadics</a>,
          a.k.a. varargs
        </li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_member_const"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const" title="add_member_const">add_member_const</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_member_const.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_const.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_member_const.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_const.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_member_const_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_member_const</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_member_const_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_member_const.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_const.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_const.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_const.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds a member <code class="computeroutput"><span class="keyword">const</span></code> qualifier
            to <code class="computeroutput"><span class="identifier">T</span></code>, if not already
            present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_const.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_const.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_member_const_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_member_const.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_const.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_const.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_const_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_const_t doesn't change anything when</span>
        <span class="comment">// the function type is already const.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_const_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_const_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_const_t can also be used with "abominable"</span>
        <span class="comment">// function types.</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_const_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_member_cv"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv" title="add_member_cv">add_member_cv</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_member_cv.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_cv.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_member_cv.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_cv.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_member_cv_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_member_cv</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_member_cv_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_member_cv.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_cv.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_cv.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_cv.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds member <code class="computeroutput"><span class="keyword">const</span></code> and <code class="computeroutput"><span class="keyword">volatile</span></code> qualifiers to <code class="computeroutput"><span class="identifier">T</span></code>,
            if not already present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_cv.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_cv.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_member_cv_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_member_cv.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_cv.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_cv.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_cv_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_cv_t doesn't change anything when</span>
        <span class="comment">// the function type is already cv-qualified.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_cv_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_cv_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_cv_t can also be used with "abominable"</span>
        <span class="comment">// function types.</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_cv_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_member_lvalue_reference"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference" title="add_member_lvalue_reference">add_member_lvalue_reference</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_member_lvalue_reference.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_lvalue_reference.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_lvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_member_lvalue_reference.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_lvalue_reference.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_member_lvalue_reference_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_member_lvalue_reference</span>
  <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_member_lvalue_reference_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_member_lvalue_reference.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_lvalue_reference.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_lvalue_reference.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_lvalue_reference.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds a member lvalue reference qualifier (<code class="computeroutput"><span class="special">&amp;</span></code>)
            to <code class="computeroutput"><span class="identifier">T</span></code>, if not already
            present.
          </li>
<li class="listitem">
            If an rvalue reference qualifier is present, the lvalue reference qualifier
            replaces it (in accordance with reference collapsing rules).
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_lvalue_reference.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_lvalue_reference.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_member_lvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_member_lvalue_reference.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_lvalue_reference.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_lvalue_reference.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_lvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_lvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_lvalue_reference_t doesn't change anything when</span>
        <span class="comment">// the function type already has an lvalue qualifier.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_lvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_lvalue_reference_t models C++11 reference collapsing</span>
        <span class="comment">// rules, so that adding an lvalue qualifier to an</span>
        <span class="comment">// rvalue-qualified type will force the lvalue.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_lvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_lvalue_reference_t can also be used to create "abominable"</span>
        <span class="comment">// function types.</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_lvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_member_rvalue_reference"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference" title="add_member_rvalue_reference">add_member_rvalue_reference</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_member_rvalue_reference.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_rvalue_reference.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_rvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_member_rvalue_reference.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_rvalue_reference.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_member_rvalue_reference_t</span> <span class="special">=</span> <span class="comment">//see below</span>


<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_member_rvalue_reference</span>
  <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_member_rvalue_reference_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_member_rvalue_reference.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_rvalue_reference.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_rvalue_reference.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_rvalue_reference.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds a member rvalue reference qualifier (<code class="computeroutput"><span class="special">&amp;&amp;</span></code>)
            to <code class="computeroutput"><span class="identifier">T</span></code>, if not already
            present.
          </li>
<li class="listitem">
            If an lvalue reference qualifier is present, the lvalue reference qualifier
            remains (in accordance with reference collapsing rules).
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_rvalue_reference.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_rvalue_reference.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_member_rvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_member_rvalue_reference.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_rvalue_reference.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_rvalue_reference.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_rvalue_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_rvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_rvalue_reference_t doesn't change anything when</span>
        <span class="comment">// the function type already has an rvalue qualifier.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_rvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_rvalue_reference_t models C++11 reference collapsing</span>
        <span class="comment">// rules, so that adding an rvalue qualifier to an</span>
        <span class="comment">// lvalue-qualified type will not change anything.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_rvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_rvalue_reference_t can also be used with "abominable"</span>
        <span class="comment">// function types.</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">()</span> <span class="keyword">const</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_rvalue_reference_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_member_volatile"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile" title="add_member_volatile">add_member_volatile</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_member_volatile.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_volatile.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_member_volatile.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_volatile.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_member_volatile_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_member_volatile</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_member_volatile_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_member_volatile.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_volatile.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_volatile.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_volatile.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds a member volatile qualifier to <code class="computeroutput"><span class="identifier">T</span></code>,
            if not already present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_member_volatile.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_volatile.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_member_volatile.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_member_volatile.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_member_volatile.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_member_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_volatile_t doesn't change anything when</span>
        <span class="comment">// the function type is already volatile.</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="comment">// add_member_volatile_t can also be used with "abominable"</span>
        <span class="comment">// function types.</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">()</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_noexcept"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept" title="add_noexcept">add_noexcept</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_noexcept.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_noexcept.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_noexcept</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_noexcept.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_noexcept.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_noexcept_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_noexcept</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_noexcept_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_noexcept.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_noexcept.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function type
                </li>
<li class="listitem">
                  function pointer type
                </li>
<li class="listitem">
                  function reference type
                </li>
<li class="listitem">
                  member function pointer type
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_noexcept.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_noexcept.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds a <code class="computeroutput"><span class="keyword">noexcept</span></code> specifier
            to <code class="computeroutput"><span class="identifier">T</span></code>, if not already
            present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_noexcept.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_noexcept.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_noexcept_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span> <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span> <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_noexcept.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_noexcept.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_noexcept.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_noexcept</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">::</span><span class="identifier">add_noexcept_t</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span>
    <span class="identifier">add_noexcept_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;,</span>
    <span class="keyword">int</span><span class="special">()</span> <span class="keyword">noexcept</span>
<span class="special">&gt;{},</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_transaction_safe"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe" title="add_transaction_safe">add_transaction_safe</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_transaction_safe.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_transaction_safe.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_transaction_safe</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_transaction_safe.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_transaction_safe.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_transaction_safe_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_transaction_safe</span>
  <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_transaction_safe_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_transaction_safe.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_transaction_safe.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function type
                </li>
<li class="listitem">
                  function pointer type
                </li>
<li class="listitem">
                  function reference type
                </li>
<li class="listitem">
                  member function pointer type
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_transaction_safe.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_transaction_safe.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds the <code class="computeroutput"><span class="identifier">transaction_safe</span></code>
            specifier to <code class="computeroutput"><span class="identifier">T</span></code>, if not
            already present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_transaction_safe.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_transaction_safe.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_transaction_safe_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_transaction_safe.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_transaction_safe.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_transaction_safe.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_transaction_safe</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">::</span><span class="identifier">add_transaction_safe_t</span><span class="special">;</span>

<span class="keyword">using</span> <span class="identifier">not_safe</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">();</span>
<span class="keyword">using</span> <span class="identifier">safe</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="identifier">transaction_safe</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">safe_added</span> <span class="special">=</span> <span class="identifier">add_transaction_safe_t</span><span class="special">&lt;</span><span class="identifier">not_safe</span><span class="special">&gt;;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">safe</span><span class="special">,</span> <span class="identifier">safe_added</span><span class="special">&gt;{},</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_add_varargs"></a><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs" title="add_varargs">add_varargs</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_add_varargs.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_varargs.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_varargs</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_add_varargs.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_varargs.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">add_varargs_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">add_varargs</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">add_varargs_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_add_varargs.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_varargs.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function type
                </li>
<li class="listitem">
                  function pointer type
                </li>
<li class="listitem">
                  function reference type
                </li>
<li class="listitem">
                  member function pointer type
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_varargs.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_varargs.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Adds C-style variadics (<code class="computeroutput"><span class="special">...</span></code>)
            to the signature of <code class="computeroutput"><span class="identifier">T</span></code>,
            if not already present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_add_varargs.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_varargs.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">add_varargs_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(...)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="special">...)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)(...)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(...)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)(...)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_add_varargs.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_add_varargs.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_add_varargs.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">add_varargs</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="special">...);</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_varargs_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">fp</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(*)();</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(*)(...);</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_varargs_t</span><span class="special">&lt;</span><span class="identifier">fp</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">fr</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*,</span> <span class="special">...);</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_varargs_t</span><span class="special">&lt;</span><span class="identifier">fr</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_varargs_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

        <span class="comment">// add_varargs_t doesn't change anything when</span>
        <span class="comment">// the type already has varargs.</span>
        <span class="keyword">using</span> <span class="identifier">twice</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">add_varargs_t</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">twice</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_apply_member_pointer"></a><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer" title="apply_member_pointer">apply_member_pointer</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_apply_member_pointer.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_member_pointer.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">apply_member_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_apply_member_pointer.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_member_pointer.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">apply_member_pointer_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">C</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">apply_member_pointer</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">apply_member_pointer_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">C</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_apply_member_pointer.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_member_pointer.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> may be any type except
            <code class="computeroutput"><span class="keyword">void</span></code>
          </li>
<li class="listitem">
            <code class="computeroutput"><span class="identifier">C</span></code> must be a user-defined
            type
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_apply_member_pointer.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_member_pointer.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function,
            function pointer (unqualified), or function reference, then the aliased
            type is a member function pointer of <code class="computeroutput"><span class="identifier">C</span></code>
            with the same parameters and return type.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a member function
            pointer (unqualified) of any type, the aliased type is a member function
            pointer of <code class="computeroutput"><span class="identifier">C</span></code> with the
            same parameters and return type.
          </li>
<li class="listitem">
            Otherwise, the aliased type is a member data pointer equivalent to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">remove_reference_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="identifier">C</span><span class="special">::*</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_apply_member_pointer.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_member_pointer.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">bar</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">bar</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">bar</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">bar</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">bar</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">bar</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*</span><span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_apply_member_pointer.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_member_pointer.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_member_pointer.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">apply_member_pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>
<span class="keyword">struct</span> <span class="identifier">bar</span><span class="special">;</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="comment">// function type -&gt; member function pointer type</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
        <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(</span><span class="keyword">int</span><span class="special">);</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="comment">// function pointer type (unqualified) -&gt; member function pointer type</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(*)();</span>
        <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>


    <span class="special">{</span>
        <span class="comment">// function pointer type (qualified) -&gt; member data pointer type</span>

        <span class="comment">// Look out for cases like these two. If the input type to apply_member_pointer</span>
        <span class="comment">// is a <span class="bold"><strong>qualified</strong></span> function pointer type, then the  aliased type is a member data</span>
        <span class="comment">// pointer to a <span class="bold"><strong>qualified function pointer</strong></span>.</span>

        <span class="special">{</span>
            <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(*&amp;)();</span>
            <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
            <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span> <span class="special">(*</span> <span class="identifier">foo</span><span class="special">::*)();</span>
            <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
        <span class="special">}</span>

        <span class="special">{</span>
            <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(*</span> <span class="keyword">const</span><span class="special">)();</span>
            <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
            <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span> <span class="special">(*</span> <span class="keyword">const</span> <span class="identifier">foo</span><span class="special">::*)();</span>
            <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
        <span class="special">}</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="comment">// function reference type -&gt; member function pointer type</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)();</span>
        <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="comment">// member function pointer type -&gt; member function pointer type</span>
        <span class="comment">// (note the different parent class)</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">bar</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="comment">// non-callable type -&gt; member data pointer type</span>
        <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>


    <span class="special">{</span>
        <span class="comment">// function object type -&gt; member data pointer type</span>
        <span class="comment">// the same is true for lambdas and generic lambdas</span>
        <span class="keyword">auto</span> <span class="identifier">lambda</span> <span class="special">=</span> <span class="special">[](){};</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">lambda</span><span class="special">);</span>
        <span class="keyword">using</span> <span class="identifier">g</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">apply_member_pointer_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">,</span> <span class="identifier">foo</span><span class="special">&gt;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">f</span> <span class="identifier">foo</span><span class="special">::*;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">g</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_apply_return"></a><a class="link" href="reference.html#callable_traits.reference.ref_apply_return" title="apply_return">apply_return</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_apply_return.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_return.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_return.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">apply_return</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_apply_return.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_return.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_return.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">apply_return_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">R</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">apply_return</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">apply_return_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">R</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_apply_return.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_return.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_return.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must one of the following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span></code> template instantiation
                </li>
<li class="listitem">
                  function
                </li>
<li class="listitem">
                  function pointer
                </li>
<li class="listitem">
                  function reference
                </li>
<li class="listitem">
                  member function pointer
                </li>
<li class="listitem">
                  member data pointer
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_apply_return.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_return.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_return.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">Args</span><span class="special">...&gt;</span></code>,
            the aliased type is <code class="computeroutput"><span class="identifier">R</span><span class="special">(</span><span class="identifier">Args</span><span class="special">...)</span></code>.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function,
            function pointer, function reference, or member function pointer, the
            aliased type's return type is <code class="computeroutput"><span class="identifier">R</span></code>,
            but is otherwise identical to <code class="computeroutput"><span class="identifier">T</span></code>.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a member data
            pointer of class <code class="computeroutput"><span class="identifier">foo</span></code>
            to a <code class="computeroutput"><span class="identifier">U</span></code> type (such that
            <code class="computeroutput"><span class="identifier">T</span></code> is <code class="computeroutput"><span class="identifier">U</span>
            <span class="identifier">foo</span><span class="special">::*</span></code>),
            the aliased type is <code class="computeroutput"><span class="identifier">R</span> <span class="identifier">foo</span><span class="special">::*</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_apply_return.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_return.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_return.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">apply_return_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*</span><span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_apply_return.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_apply_return.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_apply_return.example_program">Example
        Program</a>
      </h5>
<p>
        [apply_return]
      </p>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_args"></a><a class="link" href="reference.html#callable_traits.reference.ref_args" title="args">args</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_args.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_args.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_args.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">args</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_args.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_args.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_args.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Container</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">args_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span><span class="special">...&gt;</span> <span class="keyword">class</span> <span class="identifier">Container</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">args</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">args_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="identifier">Container</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_args.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_args.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_args.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function
                </li>
<li class="listitem">
                  function pointer
                </li>
<li class="listitem">
                  function reference
                </li>
<li class="listitem">
                  member function pointer
                </li>
<li class="listitem">
                  member data pointer
                </li>
<li class="listitem">
                  user-defined type with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
                </li>
<li class="listitem">
                  type of a non-generic lambda
                </li>
</ul></div>
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_args.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_args.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_args.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            When the constraints are violated, a substitution failure occurs.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function,
            function pointer, or function reference, the aliased type is <code class="computeroutput"><span class="identifier">Container</span></code> instantiated with the function's
            parameter types.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function
            object, the aliased type is <code class="computeroutput"><span class="identifier">Container</span></code>
            instantiated with the <code class="computeroutput"><span class="identifier">T</span><span class="special">::</span><span class="keyword">operator</span><span class="special">()</span></code> parameter types.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a member function
            pointer, the aliased type is a <code class="computeroutput"><span class="identifier">Container</span></code>
            instantiation, where the first type argument is a reference to the parent
            class of <code class="computeroutput"><span class="identifier">T</span></code>, qualified
            according to the member qualifiers on <code class="computeroutput"><span class="identifier">T</span></code>,
            such that the first type is equivalent to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">::</span><span class="identifier">qualified_class_of_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>. The subsequent type arguments, if
            any, are the parameter types of the member function.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a member data
            pointer, the aliased type is <code class="computeroutput"><span class="identifier">Container</span></code>
            with a single element, which is a <code class="computeroutput"><span class="keyword">const</span></code>
            reference to the parent class of <code class="computeroutput"><span class="identifier">T</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_args.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_args.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_args.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">args_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">)</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span> <span class="special">&amp;)(</span><span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">foo</span><span class="special">&amp;,</span>
                  <span class="keyword">float</span><span class="special">,</span>
                  <span class="keyword">char</span><span class="special">,</span>
                  <span class="keyword">int</span><span class="special">&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">volatile</span> <span class="identifier">foo</span>
                  <span class="special">&amp;&amp;&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">&amp;&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">&amp;&gt;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*</span><span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_args.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_args.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_args.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">memory</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">Expect</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">test</span><span class="special">(){</span>
    <span class="keyword">using</span> <span class="identifier">args_t</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">args_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
    <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">args_t</span><span class="special">,</span> <span class="identifier">Expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="special">}</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">auto</span> <span class="identifier">lamda</span> <span class="special">=</span> <span class="special">[](</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*){};</span>
        <span class="keyword">using</span> <span class="identifier">lam</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">lamda</span><span class="special">);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;;</span>

        <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">lam</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;();</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="identifier">foo</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;;</span>

        <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;();</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">function_ptr</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;;</span>
        <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">function_ptr</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;();</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">function_ref</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;;</span>
        <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">function_ref</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;();</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">function</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;;</span>
        <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">function</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;();</span>
    <span class="special">}</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">abominable</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*)</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;;</span>
        <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">abominable</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;();</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_class_of"></a><a class="link" href="reference.html#callable_traits.reference.ref_class_of" title="class_of">class_of</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_class_of.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_class_of.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_class_of.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">class_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_class_of.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_class_of.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_class_of.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">class_of_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">class_of</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">class_of_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_class_of.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_class_of.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_class_of.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a member pointer
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_class_of.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_class_of.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_class_of.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            The aliased type is the parent class of the member. In other words, if
            <code class="computeroutput"><span class="identifier">T</span></code> is expanded to <code class="computeroutput"><span class="identifier">U</span> <span class="identifier">C</span><span class="special">::*</span></code>, the aliased type is <code class="computeroutput"><span class="identifier">C</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_class_of.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_class_of.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_class_of.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">class_of_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span> <span class="special">&amp;)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_class_of.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_class_of.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_class_of.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">class_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">class_of_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">foo</span><span class="special">,</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">class_of_t</span><span class="special">&lt;</span><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*&gt;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_function_type"></a><a class="link" href="reference.html#callable_traits.reference.ref_function_type" title="function_type">function_type</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_function_type.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_function_type.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_function_type.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">function_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_function_type.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_function_type.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_function_type.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">function_type_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">function_type</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">function_type_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_function_type.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_function_type.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_function_type.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function
                </li>
<li class="listitem">
                  function pointer
                </li>
<li class="listitem">
                  function reference
                </li>
<li class="listitem">
                  member function pointer
                </li>
<li class="listitem">
                  member data pointer
                </li>
<li class="listitem">
                  user-defined type with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
                </li>
<li class="listitem">
                  type of a non-generic lambda
                </li>
</ul></div>
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_function_type.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_function_type.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_function_type.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            When the constraints are violated, a substitution failure occurs.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function,
            the aliased type is identical to <code class="computeroutput"><span class="identifier">T</span></code>,
            except that the aliased function type will not have member qualifiers
            or the <code class="computeroutput"><span class="identifier">transaction_safe</span></code>
            specifier.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function
            pointer, the aliased type is equivalent to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">remove_pointer_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function
            reference, the aliased type is equivalent to <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">remove_reference_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a function
            object, the aliased type is a function type with the same return type
            and parameter list as <code class="computeroutput"><span class="identifier">T</span></code>'s
            <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a member function
            pointer, the aliased type is a function type with the same return type
            as <code class="computeroutput"><span class="identifier">T</span></code>, and the first parameter
            is a reference to the parent class of <code class="computeroutput"><span class="identifier">T</span></code>,
            qualified according to the member qualifiers on <code class="computeroutput"><span class="identifier">T</span></code>.
            The subsequent parameters, if any, are the parameter types of <code class="computeroutput"><span class="identifier">T</span></code>.
          </li>
<li class="listitem">
            When <code class="computeroutput"><span class="identifier">T</span></code> is a member data
            pointer, the aliased type is a function type returning the underlying
            member type of <code class="computeroutput"><span class="identifier">T</span></code>, taking
            a single parameter, which is a <code class="computeroutput"><span class="keyword">const</span></code>
            reference to the parent type of <code class="computeroutput"><span class="identifier">T</span></code>.
          </li>
<li class="listitem">
            In all cases, the aliased function type will not have member qualifiers,
            and will not have the <code class="computeroutput"><span class="identifier">transaction_safe</span></code>
            specifier.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_function_type.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_function_type.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_function_type.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">function_type_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*</span><span class="keyword">const</span> <span class="special">&amp;)(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*</span>
                  <span class="keyword">volatile</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">&amp;,</span>
                  <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">&amp;,</span> <span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">volatile</span> <span class="identifier">foo</span><span class="special">&amp;&amp;)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">&amp;)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">foo</span><span class="special">&amp;)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_function_type.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_function_type.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_function_type.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">test</span><span class="special">(){</span>

    <span class="comment">// this example shows how boost::callable_traits::function_type_t</span>
    <span class="comment">// bevaves consistently for many different types</span>
    <span class="keyword">using</span> <span class="identifier">type</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">function_type_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
    <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
    <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">expect</span><span class="special">,</span> <span class="identifier">type</span><span class="special">&gt;{},</span> <span class="string">""</span><span class="special">);</span>
<span class="special">}</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="keyword">auto</span> <span class="identifier">lamda</span> <span class="special">=</span> <span class="special">[](</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*){};</span>
    <span class="keyword">using</span> <span class="identifier">lam</span> <span class="special">=</span> <span class="keyword">decltype</span><span class="special">(</span><span class="identifier">lamda</span><span class="special">);</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">lam</span><span class="special">&gt;();</span>

    <span class="keyword">using</span> <span class="identifier">function_ptr</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(*)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">function_ptr</span><span class="special">&gt;();</span>

    <span class="keyword">using</span> <span class="identifier">function_ref</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">function_ref</span><span class="special">&gt;();</span>

    <span class="keyword">using</span> <span class="identifier">function</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">function</span><span class="special">&gt;();</span>

    <span class="keyword">using</span> <span class="identifier">abominable</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="keyword">float</span><span class="special">&amp;,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*)</span> <span class="keyword">const</span><span class="special">;</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="identifier">abominable</span><span class="special">&gt;();</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_has_member_qualifiers"></a><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers" title="has_member_qualifiers">has_member_qualifiers</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_has_member_qualifiers.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_member_qualifiers.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">has_member_qualifiers</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_has_member_qualifiers.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_member_qualifiers.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_member_qualifiers</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">has_member_qualifiers_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_has_member_qualifiers.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_member_qualifiers.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_has_member_qualifiers.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_member_qualifiers.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">false_type</span></code> is inherited by <code class="computeroutput"><span class="identifier">has_member_qualifiers</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
            and is aliased by <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">has_member_qualifiers</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code>, except when one of the following
            criteria is met, in which case <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">true_type</span></code>
            would be similarly inherited and aliased:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  with member qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a member function
                  pointer with member qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a member-qualified <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">has_member_qualifiers_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">has_member_qualifiers</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_has_member_qualifiers.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_member_qualifiers.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">has_member_qualifiers_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*&amp;)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_has_member_qualifiers.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_member_qualifiers.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_member_qualifiers.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">has_member_qualifiers</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_member_qualifiers</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_member_qualifiers</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_member_qualifiers</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_has_varargs"></a><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs" title="has_varargs">has_varargs</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_has_varargs.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_varargs.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">has_varargs</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_has_varargs.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_varargs.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_varargs</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">has_varargs_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_has_varargs.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_varargs.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_has_varargs.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_varargs.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">false_type</span></code> is inherited by <code class="computeroutput"><span class="identifier">has_varargs</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
            and is aliased by <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">has_varargs</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code>, except when one of the following
            criteria is met, in which case <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">true_type</span></code>
            would be similarly inherited and aliased:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function,
                  function pointer, or function reference where the function's parameter
                  list includes C-style variadics.
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with C-style variadics in the parameter list.
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, which has C-style variadics
                  in the parameter list of its <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>.
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">has_varargs_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">has_varargs</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_has_varargs.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_varargs.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">has_varargs_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="special">...)</span> <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*</span>
                  <span class="keyword">volatile</span><span class="special">)(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(&amp;)(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_has_varargs.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_varargs.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_varargs.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">has_varargs</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_varargs</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(...)&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_varargs</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_has_void_return"></a><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return" title="has_void_return">has_void_return</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_has_void_return.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_void_return.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">has_void_return</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_has_void_return.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_void_return.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">has_void_return</span><span class="special">;</span>


<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">has_void_return_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_has_void_return.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_void_return.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_has_void_return.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_void_return.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">false_type</span></code> is inherited by <code class="computeroutput"><span class="identifier">has_void_return</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
            and is aliased by <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">has_void_return</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span></code>, except when one of the following
            criteria is met, in which case <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">true_type</span></code>
            would be similarly inherited and aliased:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function,
                  function pointer, or function reference where the function's return
                  type is <code class="computeroutput"><span class="keyword">void</span></code>.
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function whose return type is <code class="computeroutput"><span class="keyword">void</span></code>.
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> function returns <code class="computeroutput"><span class="keyword">void</span></code>.
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">has_void_return_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">has_void_return</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_has_void_return.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_void_return.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">has_void_return_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span> <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(*</span>
                  <span class="keyword">const</span> <span class="special">&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">*</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_has_void_return.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_has_void_return.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_has_void_return.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">has_void_return</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_void_return</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">has_void_return</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_const_member"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member" title="is_const_member">is_const_member</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_const_member.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_const_member.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_const_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_const_member.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_const_member.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_const_member</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_const_member_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_const_member.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_const_member.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_const_member.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_const_member.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_const_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
            when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type with a <code class="computeroutput"><span class="keyword">const</span></code>
                  member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with a <code class="computeroutput"><span class="keyword">const</span></code>
                  member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a <code class="computeroutput"><span class="keyword">const</span></code>
                  member qualifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_const_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_const_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_const_member.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_const_member.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_const_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*&amp;)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_const_member.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_const_member.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_const_member.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_const_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_const_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_const_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_cv_member"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member" title="is_cv_member">is_cv_member</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_cv_member.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_cv_member.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_cv_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_cv_member.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_cv_member.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_cv_member</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_cv_member_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_cv_member.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_cv_member.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_cv_member.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_cv_member.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_cv_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
            when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type with both <code class="computeroutput"><span class="keyword">const</span></code>
                  and <code class="computeroutput"><span class="keyword">volatile</span></code> member
                  qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with both <code class="computeroutput"><span class="keyword">const</span></code>
                  and <code class="computeroutput"><span class="keyword">volatile</span></code> member
                  qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has both <code class="computeroutput"><span class="keyword">const</span></code>
                  and <code class="computeroutput"><span class="keyword">volatile</span></code> member
                  qualifiers
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_cv_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_cv_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_cv_member.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_cv_member.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_cv_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span> <span class="special">&amp;)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_cv_member.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_cv_member.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_cv_member.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_cv_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_cv_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_cv_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_cv_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_cv_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_invocable"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_invocable" title="is_invocable">is_invocable</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_invocable.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_invocable.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_invocable.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_invocable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_invocable.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_invocable.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_invocable.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_invocable</span><span class="special">;</span>

<span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_invocable_r</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_invocable_v</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Ret</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span><span class="special">...</span> <span class="identifier">Args</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_invocable_r_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_invocable.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_invocable.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_invocable.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_invocable.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_invocable.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_invocable.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
<p class="simpara">
            standalone c++11 implementation of c++17 <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_invocable</span></code>,
            <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_invocable_r</span></code>
          </p>
<div class="note"><table border="0" summary="Note">
<tr>
<td rowspan="2" align="center" valign="top" width="25"><img alt="[Note]" src="../../../../../doc/src/images/note.png"></td>
<th align="left">Note</th>
</tr>
<tr><td align="left" valign="top"><p>
              ref-qualified overloads of <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> with different signatures are not
              handled correctly yet.
            </p></td></tr>
</table></div>
</li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_invocable.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_invocable.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_invocable.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_invocable</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{</span>
    <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
    <span class="keyword">typename</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">enable_if</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_integral</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">&gt;::</span><span class="identifier">type</span>
    <span class="keyword">operator</span><span class="special">()(</span><span class="identifier">T</span><span class="special">){}</span>
<span class="special">};</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_invocable</span><span class="special">&lt;</span><span class="identifier">foo</span><span class="special">,</span> <span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_invocable</span><span class="special">&lt;</span><span class="identifier">foo</span><span class="special">,</span> <span class="keyword">double</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_lvalue_reference_member"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member" title="is_lvalue_reference_member">is_lvalue_reference_member</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_lvalue_reference_member.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_lvalue_reference_member.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_lvalue_reference_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_lvalue_reference_member.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_lvalue_reference_member.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_lvalue_reference_member</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_lvalue_reference_member_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_lvalue_reference_member.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_lvalue_reference_member.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_lvalue_reference_member.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_lvalue_reference_member.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
            is <code class="computeroutput"><span class="keyword">true</span></code> when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type with a '&amp;' member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with a '&amp;' member qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a '&amp;' member qualifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_lvalue_reference_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_lvalue_reference_member.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_lvalue_reference_member.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_lvalue_reference_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_lvalue_reference_member.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_lvalue_reference_member.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_lvalue_reference_member.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_lvalue_reference_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&amp;&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&amp;&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_lvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_reference_member"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member" title="is_reference_member">is_reference_member</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_reference_member.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_reference_member.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_reference_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_reference_member.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_reference_member.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_reference_member</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_reference_member_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_reference_member.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_reference_member.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_reference_member.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_reference_member.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
            when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type with a '&amp;' or '&amp;&amp;' member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with a '&amp;' or '&amp;&amp;' member qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a '&amp;' or '&amp;&amp;'
                  member qualifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_reference_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_reference_member.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_reference_member.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_reference_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_reference_member.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_reference_member.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_reference_member.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_reference_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&amp;&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&amp;&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_rvalue_reference_member"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member" title="is_rvalue_reference_member">is_rvalue_reference_member</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_rvalue_reference_member.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_rvalue_reference_member.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_rvalue_reference_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_rvalue_reference_member.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_rvalue_reference_member.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_rvalue_reference_member</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_rvalue_reference_member_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_rvalue_reference_member.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_rvalue_reference_member.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_rvalue_reference_member.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_rvalue_reference_member.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>
            is <code class="computeroutput"><span class="keyword">true</span></code> when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type with a '&amp;&amp;' member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with a '&amp;&amp;' member qualifiers
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a '&amp;&amp;' member qualifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_rvalue_reference_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_rvalue_reference_member.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_rvalue_reference_member.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_rvalue_reference_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">volatile</span><span class="special">)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_rvalue_reference_member.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_rvalue_reference_member.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_rvalue_reference_member.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_rvalue_reference_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&amp;&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&amp;&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&amp;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_rvalue_reference_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_noexcept"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept" title="is_noexcept">is_noexcept</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_noexcept.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_noexcept.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_noexcept</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_noexcept.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_noexcept.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_noexcept</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_noexcept_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_noexcept.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_noexcept.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            none
          </li>
<li class="listitem"><h5>
<a name="callable_traits.reference.ref_is_noexcept.h3"></a>
            <span class="phrase"><a name="callable_traits.reference.ref_is_noexcept.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept.behavior">Behavior</a>
          </h5></li>
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
            when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type, function pointer type, function reference type, or member
                  function pointer type where the function has a <code class="computeroutput"><span class="keyword">noexcept</span></code>
                  specifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a <code class="computeroutput"><span class="keyword">noexcept</span></code>
                  specifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_noexcept_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_noexcept.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_noexcept.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_noexcept_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*</span>
                  <span class="keyword">const</span> <span class="special">&amp;)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_noexcept.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_noexcept.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_noexcept.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_noexcept</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(*)()</span> <span class="keyword">noexcept</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)()</span> <span class="keyword">noexcept</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">noexcept</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_noexcept</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_transaction_safe"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe" title="is_transaction_safe">is_transaction_safe</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_transaction_safe.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_transaction_safe.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_transaction_safe</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_transaction_safe.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_transaction_safe.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_transaction_safe</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_transaction_safe_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_transaction_safe.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_transaction_safe.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            none
          </li>
<li class="listitem"><h5>
<a name="callable_traits.reference.ref_is_transaction_safe.h3"></a>
            <span class="phrase"><a name="callable_traits.reference.ref_is_transaction_safe.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe.behavior">Behavior</a>
          </h5></li>
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
            when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type, function pointer type, function reference type, or member
                  function pointer type where the function has a <code class="computeroutput"><span class="identifier">transaction_safe</span></code>
                  specifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a <code class="computeroutput"><span class="identifier">transaction_safe</span></code>
                  specifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_transaction_safe_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_transaction_safe.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_transaction_safe.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_transaction_safe_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_transaction_safe.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_transaction_safe.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_transaction_safe.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_transaction_safe</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()</span> <span class="identifier">transaction_safe</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(*)()</span> <span class="identifier">transaction_safe</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)()</span> <span class="identifier">transaction_safe</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="identifier">transaction_safe</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_transaction_safe</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_is_volatile_member"></a><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member" title="is_volatile_member">is_volatile_member</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_is_volatile_member.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_volatile_member.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_volatile_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_is_volatile_member.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_volatile_member.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="comment">// inherits from either std::true_type or std::false_type</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_volatile_member</span><span class="special">;</span>

<span class="comment">// only available when variable templates are supported</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">constexpr</span> <span class="keyword">bool</span> <span class="identifier">is_volatile_member_v</span> <span class="special">=</span> <span class="comment">//see below</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_is_volatile_member.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_volatile_member.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            none
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_is_volatile_member.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_volatile_member.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>
            when either:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  type with a <code class="computeroutput"><span class="keyword">volatile</span></code>
                  member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a pointer
                  to a member function with a <code class="computeroutput"><span class="keyword">volatile</span></code>
                  member qualifier
                </li>
<li class="listitem">
                  <code class="computeroutput"><span class="identifier">T</span></code> is a function
                  object with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>, where the <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code> has a <code class="computeroutput"><span class="keyword">volatile</span></code>
                  member qualifier
                </li>
</ul></div>
          </li>
<li class="listitem">
            On compilers that support variable templates, <code class="computeroutput"><span class="identifier">is_volatile_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> is equivalent to <code class="computeroutput"><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_is_volatile_member.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_volatile_member.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">is_volatile_member_v</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">true</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">volatile</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">false</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_is_volatile_member.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_is_volatile_member.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_is_volatile_member.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">is_volatile_member</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
<span class="keyword">static_assert</span><span class="special">(!</span><span class="identifier">ct</span><span class="special">::</span><span class="identifier">is_volatile_member</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_qualified_class_of"></a><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of" title="qualified_class_of">qualified_class_of</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_qualified_class_of.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_qualified_class_of.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">qualified_class_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_qualified_class_of.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_qualified_class_of.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">qualified_class_of_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">qualified_class_of</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">qualified_class_of_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_qualified_class_of.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_qualified_class_of.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a member pointer
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_qualified_class_of.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_qualified_class_of.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a member function
            pointer, the aliased type is the parent class of the member, qualified
            according to the member qualifiers on <code class="computeroutput"><span class="identifier">T</span></code>.
            If <code class="computeroutput"><span class="identifier">T</span></code> does not have a
            member reference qualifier, then the aliased type will be an lvalue reference.
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a member data
            pointer, the aliased type is equivalent to <code class="computeroutput"><span class="identifier">ct</span><span class="special">::</span><span class="identifier">class_of</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_qualified_class_of.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_qualified_class_of.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">qualified_class_of_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span> <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">volatile</span><span class="special">)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span> <span class="keyword">const</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*&amp;)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span> <span class="keyword">volatile</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span> <span class="keyword">const</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">int</span>
                  <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="identifier">foo</span> <span class="keyword">const</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_qualified_class_of.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_qualified_class_of.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_qualified_class_of.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">qualified_class_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">foo</span> <span class="special">&amp;,</span>
    <span class="identifier">ct</span><span class="special">::</span><span class="identifier">qualified_class_of_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()&gt;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">foo</span> <span class="keyword">const</span> <span class="special">&amp;,</span>
    <span class="identifier">ct</span><span class="special">::</span><span class="identifier">qualified_class_of_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">foo</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;,</span>
    <span class="identifier">ct</span><span class="special">::</span><span class="identifier">qualified_class_of_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;&gt;&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_member_const"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const" title="remove_member_const">remove_member_const</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_const.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_const.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_const.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_const.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_member_const_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_member_const</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_member_const_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_const.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_const.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_const.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_const.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Removes the member <code class="computeroutput"><span class="keyword">const</span></code>
            qualifier from <code class="computeroutput"><span class="identifier">T</span></code>, if
            present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_const.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_const.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_member_const_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_const.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_const.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_const.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_const</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_const_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_const_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_const_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_const_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_member_cv"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv" title="remove_member_cv">remove_member_cv</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_cv.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_cv.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_cv.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_cv.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_member_cv_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_member_cv</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_member_cv_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_cv.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_cv.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_cv.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_cv.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Removes member <code class="computeroutput"><span class="keyword">const</span></code> and/or
            <code class="computeroutput"><span class="keyword">volatile</span></code> qualifiers from
            <code class="computeroutput"><span class="identifier">T</span></code>, if present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_cv.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_cv.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_member_cv_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_cv.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_cv.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_cv.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_cv</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_cv_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_cv_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_cv_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_cv_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_member_reference"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference" title="remove_member_reference">remove_member_reference</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_reference.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_reference.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_reference.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_reference.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_member_reference_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_member_reference</span>
  <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_member_reference_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_reference.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_reference.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_reference.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_reference.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occuers if the constraints are violated.
          </li>
<li class="listitem">
            Removes member <code class="computeroutput"><span class="special">&amp;</span></code> or
            <code class="computeroutput"><span class="special">&amp;&amp;</span></code> qualifiers from
            <code class="computeroutput"><span class="identifier">T</span></code>, if present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_reference.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_reference.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_member_const_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_reference.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_reference.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_reference.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_reference</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_reference_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_reference_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_member_volatile"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile" title="remove_member_volatile">remove_member_volatile</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_volatile.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_volatile.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_volatile.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_volatile.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_member_volatile_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_member_volatile</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_member_volatile_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_member_volatile.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_volatile.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be a function
            type or a member function pointer type
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_volatile.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_volatile.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Removes the member <code class="computeroutput"><span class="keyword">volatile</span></code>
            qualifier from <code class="computeroutput"><span class="identifier">T</span></code>, if
            present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_volatile.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_volatile.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span> <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span> <span class="keyword">volatile</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_member_volatile.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_member_volatile.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_member_volatile.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_member_volatile</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">volatile</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="special">&amp;;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span> <span class="keyword">volatile</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_member_volatile_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_noexcept"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept" title="remove_noexcept">remove_noexcept</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_noexcept.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_noexcept.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_noexcept</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_noexcept.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_noexcept.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_noexcept_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_noexcept</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_noexcept_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_noexcept.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_noexcept.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function type
                </li>
<li class="listitem">
                  function pointer type
                </li>
<li class="listitem">
                  function reference type
                </li>
<li class="listitem">
                  member function pointer type
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_noexcept.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_noexcept.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Removes the <code class="computeroutput"><span class="keyword">noexcept</span></code> specifier
            from <code class="computeroutput"><span class="identifier">T</span></code>, if present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_noexcept.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_noexcept.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_noexcept_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">noexcept</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_noexcept.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_noexcept.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_noexcept.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_noexcept</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">using</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">::</span><span class="identifier">remove_noexcept_t</span><span class="special">;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span>
    <span class="identifier">remove_noexcept_t</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()</span> <span class="keyword">noexcept</span><span class="special">&gt;,</span>
    <span class="keyword">int</span><span class="special">()</span>
<span class="special">&gt;{},</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_transaction_safe"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe" title="remove_transaction_safe">remove_transaction_safe</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_transaction_safe.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_transaction_safe.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_transaction_safe</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_transaction_safe.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_transaction_safe.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_transaction_safe_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_transaction_safe</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_transaction_safe_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_transaction_safe.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_transaction_safe.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function type
                </li>
<li class="listitem">
                  function pointer type
                </li>
<li class="listitem">
                  function reference type
                </li>
<li class="listitem">
                  member function pointer type
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_transaction_safe.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_transaction_safe.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Removes the member <code class="computeroutput"><span class="identifier">transaction_safe</span></code>
            specifier from <code class="computeroutput"><span class="identifier">T</span></code>, if
            present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_transaction_safe.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_transaction_safe.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_transaction_safe_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span> <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(</span><span class="identifier">foo</span><span class="special">::*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_transaction_safe.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_transaction_safe.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_transaction_safe.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_transaction_safe</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">using</span> <span class="identifier">ts</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">()</span> <span class="identifier">transaction_safe</span><span class="special">;</span>
<span class="keyword">using</span> <span class="identifier">not_ts</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">();</span>
<span class="keyword">using</span> <span class="identifier">ts_removed</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_transaction_safe_t</span><span class="special">&lt;</span><span class="identifier">ts</span><span class="special">&gt;;</span>

<span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">not_ts</span><span class="special">,</span> <span class="identifier">ts_removed</span><span class="special">&gt;{},</span> <span class="string">""</span><span class="special">);</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_remove_varargs"></a><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs" title="remove_varargs">remove_varargs</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_remove_varargs.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_varargs.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_varargs</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_remove_varargs.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_varargs.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">remove_varargs_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">remove_varargs</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">remove_varargs_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_remove_varargs.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_varargs.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function type
                </li>
<li class="listitem">
                  function pointer type
                </li>
<li class="listitem">
                  function reference type
                </li>
<li class="listitem">
                  member function pointer type
                </li>
</ul></div>
          </li>
<li class="listitem">
            If <code class="computeroutput"><span class="identifier">T</span></code> is a pointer, it
            may not be cv/ref qualified
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_varargs.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_varargs.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            A substitution failure occurs if the constraints are violated.
          </li>
<li class="listitem">
            Removes C-style variadics (<code class="computeroutput"><span class="special">...</span></code>)
            from the signature of <code class="computeroutput"><span class="identifier">T</span></code>,
            if present.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_remove_varargs.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_varargs.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">remove_varargs_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="special">...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="keyword">int</span><span class="special">)</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(&amp;)(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(&amp;)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="special">&amp;&amp;</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="identifier">transaction_safe</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="identifier">foo</span><span class="special">::*</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*</span>
                  <span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_remove_varargs.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_remove_varargs.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_remove_varargs.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">remove_varargs</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span> <span class="special">{};</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">f</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">,</span> <span class="special">...);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="keyword">int</span><span class="special">);</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_varargs_t</span><span class="special">&lt;</span><span class="identifier">f</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">fp</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(*)(...);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(*)();</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_varargs_t</span><span class="special">&lt;</span><span class="identifier">fp</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">fr</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*,</span> <span class="special">...);</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(&amp;)(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*);</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_varargs_t</span><span class="special">&lt;</span><span class="identifier">fr</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span> <span class="special">{</span>
        <span class="keyword">using</span> <span class="identifier">pmf</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)(...)</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">void</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">;</span>
        <span class="keyword">using</span> <span class="identifier">test</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">remove_varargs_t</span><span class="special">&lt;</span><span class="identifier">pmf</span><span class="special">&gt;;</span>
        <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">test</span><span class="special">,</span> <span class="identifier">expect</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">,</span> <span class="string">""</span><span class="special">);</span>
    <span class="special">}</span>
<span class="special">}</span>
</pre>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="callable_traits.reference.ref_return_type"></a><a class="link" href="reference.html#callable_traits.reference.ref_return_type" title="return_type">return_type</a>
</h3></div></div></div>
<h5>
<a name="callable_traits.reference.ref_return_type.h0"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_return_type.header"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_return_type.header">Header</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">/</span><span class="identifier">return_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></pre>
<h5>
<a name="callable_traits.reference.ref_return_type.h1"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_return_type.definition"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_return_type.definition">Definition</a>
      </h5>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">using</span> <span class="identifier">return_type_t</span> <span class="special">=</span> <span class="comment">//see below</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">return_type</span> <span class="special">:</span> <span class="identifier">detail</span><span class="special">::</span><span class="identifier">return_type_impl</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">{};</span>
</pre>
<h5>
<a name="callable_traits.reference.ref_return_type.h2"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_return_type.constraints"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_return_type.constraints">Constraints</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; "><li class="listitem">
            <code class="computeroutput"><span class="identifier">T</span></code> must be one of the
            following:
            <div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: circle; ">
<li class="listitem">
                  function
                </li>
<li class="listitem">
                  function pointer
                </li>
<li class="listitem">
                  function reference
                </li>
<li class="listitem">
                  member function pointer
                </li>
<li class="listitem">
                  member data pointer
                </li>
<li class="listitem">
                  user-defined type with a non-overloaded <code class="computeroutput"><span class="keyword">operator</span><span class="special">()</span></code>
                </li>
<li class="listitem">
                  type of a non-generic lambda
                </li>
</ul></div>
          </li></ul></div>
<h5>
<a name="callable_traits.reference.ref_return_type.h3"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_return_type.behavior"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_return_type.behavior">Behavior</a>
      </h5>
<div class="itemizedlist"><ul class="itemizedlist" style="list-style-type: disc; ">
<li class="listitem">
            When the constraints are violated, a substitution failure occurs.
          </li>
<li class="listitem">
            The aliased type is the return type of <code class="computeroutput"><span class="identifier">T</span></code>.
          </li>
</ul></div>
<h5>
<a name="callable_traits.reference.ref_return_type.h4"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_return_type.input_output_examples"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_return_type.input_output_examples">Input/Output
        Examples</a>
      </h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">T</span></code>
                </p>
              </th>
<th>
                <p>
                  <code class="computeroutput"><span class="identifier">return_type_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span>
                  <span class="identifier">std</span><span class="special">::</span><span class="identifier">tuple</span><span class="special">&gt;</span></code>
                </p>
              </th>
</tr></thead>
<tbody>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span><span class="special">()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">void</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span><span class="special">(*)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">float</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*(&amp;)()</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">const</span> <span class="keyword">char</span>
                  <span class="special">*</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span>
                  <span class="keyword">const</span></code>
                </p>
              </td>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
<tr>
<td>
                <p>
                  <code class="computeroutput"><span class="keyword">int</span> <span class="special">(*</span><span class="keyword">const</span><span class="special">)()</span></code>
                </p>
              </td>
<td>
                <p>
                  (substitution failure)
                </p>
              </td>
</tr>
</tbody>
</table></div>
<h5>
<a name="callable_traits.reference.ref_return_type.h5"></a>
        <span class="phrase"><a name="callable_traits.reference.ref_return_type.example_program"></a></span><a class="link" href="reference.html#callable_traits.reference.ref_return_type.example_program">Example
        Program</a>
      </h5>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">type_traits</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">callable_traits</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>

<span class="keyword">namespace</span> <span class="identifier">ct</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">callable_traits</span><span class="special">;</span>

<span class="keyword">using</span> <span class="identifier">expect</span> <span class="special">=</span> <span class="keyword">int</span><span class="special">;</span>

<span class="keyword">struct</span> <span class="identifier">foo</span><span class="special">;</span>

<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">test</span><span class="special">()</span> <span class="special">{</span>
    <span class="keyword">using</span> <span class="identifier">result</span> <span class="special">=</span> <span class="identifier">ct</span><span class="special">::</span><span class="identifier">return_type_t</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;;</span>
    <span class="keyword">static_assert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">is_same</span><span class="special">&lt;</span><span class="identifier">expect</span><span class="special">,</span> <span class="identifier">result</span><span class="special">&gt;{},</span> <span class="string">""</span><span class="special">);</span>
<span class="special">}</span>

<span class="keyword">int</span> <span class="identifier">main</span><span class="special">()</span> <span class="special">{</span>

    <span class="identifier">test</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()&gt;();</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(*)()&gt;();</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(&amp;)()&gt;();</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">()</span> <span class="keyword">const</span><span class="special">&gt;();</span>
    <span class="identifier">test</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">(</span><span class="identifier">foo</span><span class="special">::*)()</span> <span class="keyword">const</span><span class="special">&gt;();</span>

    <span class="keyword">auto</span> <span class="identifier">x</span> <span class="special">=</span> <span class="special">[]()</span> <span class="special">-&gt;</span> <span class="keyword">int</span> <span class="special">{</span> <span class="keyword">return</span> <span class="number">0</span><span class="special">;</span> <span class="special">};</span>

    <span class="identifier">test</span><span class="special">&lt;</span><span class="keyword">decltype</span><span class="special">(</span><span class="identifier">x</span><span class="special">)&gt;();</span>
<span class="special">}</span>
</pre>
</div>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer">Copyright © 2016-2018 Barrett Adair<p>
        Distributed under the Boost Software License, Version 1.0. (See accompanying
        file LICENSE.md or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
      </p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="faq.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>
